home *** CD-ROM | disk | FTP | other *** search
/ Skunkware 5 / Skunkware 5.iso / src / X11 / xsw / psmem.c < prev    next >
C/C++ Source or Header  |  1995-07-07  |  42KB  |  1,483 lines
  1. /*
  2.  *    @(#) psmem.c 12.1 95/07/07 SCOINC
  3.  */
  4. /***************************************************************************
  5.  *
  6.  *    Copyright (c) 1990-1993        The Santa Cruz Operation, Inc.
  7.  *
  8.  *    All rights reserved.  No part of this program or publication may be
  9.  *    reproduced, transmitted, transcribed, stored in a retrieval system,
  10.  *    or translated into any language or computer language, in any form or
  11.  *    by any means, electronic, mechanical, magnetic, optical, chemical,
  12.  *    biological, or otherwise, without the prior written permission of:
  13.  *
  14.  *        The Santa Cruz Operation , Inc.        (408) 425-7222
  15.  *        400 Encinal St., Santa Cruz, California 95060 USA
  16.  *
  17.  **************************************************************************/
  18. /*
  19.  * Modification History
  20.  *
  21.  * S002, 25-Oct-93, rickra
  22.  *    Fixed some new compiler warnings.....
  23.  *
  24.  * S001, 15-Sep-93, rickra
  25.  *    Removed sort order on a per VIEW basis...
  26.  *    Fixed little bugs here and there...
  27.  *
  28.  * S000, 27-May-93, rickra
  29.  *        Added support for the VIEW....
  30.  */
  31. /*+-------------------------------------------------------------------------
  32.     psmem.c - XSW PS MEM status detail
  33.  
  34.   Defined functions:
  35.  
  36. --------------------------------------------------------------------------*/
  37.  
  38. #include <X11/Xlib.h>
  39. #include <X11/Xutil.h>
  40. #include <X11/Intrinsic.h>
  41. #include <X11/Shell.h>
  42. #include <X11/StringDefs.h>
  43. #include <Xm/Xm.h>
  44. #include <Xm/MainW.h>
  45. #include <Xm/DrawingA.h>
  46.  
  47. #include "include/unixincs.h"
  48. #include "include/resources.h"
  49. #include "include/xswboth.h"
  50. #include "include/buttons.h"
  51. #include "include/libkmem.h"
  52. #include "include/libmem.h"
  53. #include "include/libswap.h"
  54. #include "include/xsw.h"
  55. #include "include/psmem.h"
  56.  
  57. extern struct NetworkXswStruct *current_server;
  58.  
  59. #define MEM_UID_X           0
  60. #define MEM_PID_X           10
  61. #define MEM_VSIZE_X         18
  62. #define MEM_SHRD_X          25
  63. #define MEM_PRIV_X          31
  64. #define MEM_WTD_X           37
  65. #define MEM_TOTAL_X         43
  66.  
  67. #define MEM_SWAP_X          49
  68. #define MEM_FILE_X          57
  69.  
  70.  
  71. /*+-------------------------------------------------------------------------
  72.         process_mem_user_compare(ppp1,ppp2)
  73. --------------------------------------------------------------------------*/
  74. process_mem_user_compare (ppp1, ppp2)
  75.      register process_memory *ppp1;
  76.      register process_memory *ppp2;
  77. {
  78.  
  79.   if (current_server -> ps_mem_sort_order == 1)
  80.     return (strcmp (ppp2 -> name, ppp1 -> name));
  81.   else
  82.     return (strcmp (ppp1 -> name, ppp2 -> name));
  83.  
  84. }                /* end of process_io_user_compare */
  85.  
  86.  
  87. /*+-------------------------------------------------------------------------
  88.         process_mem_pid_compare(ppp1,ppp2)
  89. --------------------------------------------------------------------------*/
  90. process_mem_pid_compare (ppp1, ppp2)
  91.      register process_memory *ppp1;
  92.      register process_memory *ppp2;
  93. {
  94.  
  95.   if (current_server -> ps_mem_sort_order == 1)
  96.     return (ppp2 -> p_pid - ppp1 -> p_pid);
  97.   else
  98.     return (ppp1 -> p_pid - ppp2 -> p_pid);
  99.  
  100. }                /* end of process_mem_pid_compare */
  101.  
  102. /*+-------------------------------------------------------------------------
  103.         process_mem_vsize_compare(ppp1,ppp2)
  104. --------------------------------------------------------------------------*/
  105. process_mem_vsize_compare (ppp1, ppp2)
  106.      register process_memory *ppp1;
  107.      register process_memory *ppp2;
  108. {
  109.  
  110.   if (current_server -> ps_mem_sort_order == 1)
  111.     return (ppp2 -> virtual - ppp1 -> virtual);
  112.   else
  113.     return (ppp1 -> virtual - ppp2 -> virtual);
  114.  
  115. }                /* end of process_mem_vsize_compare */
  116.  
  117.  
  118.  
  119.  
  120.  
  121. /*+-------------------------------------------------------------------------
  122.         process_mem_shrd_compare(ppp1,ppp2)
  123. --------------------------------------------------------------------------*/
  124. process_mem_shrd_compare (ppp1, ppp2)
  125.      register process_memory *ppp1;
  126.      register process_memory *ppp2;
  127. {
  128.   if (current_server -> ps_mem_sort_order == 1)
  129.     return (ppp2 -> shared - ppp1 -> shared);
  130.   else
  131.     return (ppp1 -> shared - ppp2 -> shared);
  132.  
  133. }                /* end of process_mem_shrd_compare */
  134.  
  135. /*+-------------------------------------------------------------------------
  136.         process_mem_priv_compare(ppp1,ppp2)
  137. --------------------------------------------------------------------------*/
  138. process_mem_priv_compare (ppp1, ppp2)
  139.      register process_memory *ppp1;
  140.      register process_memory *ppp2;
  141.  
  142. {
  143.  
  144.   if (current_server -> ps_mem_sort_order == 1)
  145.     return (ppp2 -> private - ppp1 -> private);
  146.   else
  147.     return (ppp1 -> private - ppp2 -> private);
  148.  
  149. }                /* end of process_mem_priv_compare */
  150.  
  151. /*+-------------------------------------------------------------------------
  152.         process_mem_wtd_compare(ppp1,ppp2)
  153. --------------------------------------------------------------------------*/
  154. process_mem_wtd_compare (ppp1, ppp2)
  155.      register process_memory *ppp1;
  156.      register process_memory *ppp2;
  157. {
  158.  
  159.   if (current_server -> ps_mem_sort_order == 1)
  160.     return (ppp2 -> weighted - ppp1 -> weighted);
  161.   else
  162.     return (ppp1 -> weighted - ppp2 -> weighted);
  163.  
  164. }                /* end of process_mem_wtd_compare */
  165.  
  166.  
  167.  
  168. /*+-------------------------------------------------------------------------
  169.     process_memory_compare(ppp1,ppp2)
  170. --------------------------------------------------------------------------*/
  171. process_memory_compare (ppp1, ppp2)
  172.      register process_memory *ppp1;
  173.      register process_memory *ppp2;
  174. {
  175.  
  176.  
  177.   if (current_server -> ps_mem_sort_order == 1)
  178.     return (ppp2 -> total - ppp1 -> total);
  179.   else
  180.     return (ppp1 -> total - ppp2 -> total);
  181.  
  182.  
  183. }                /* end of process_memory_compare */
  184.  
  185. /*+-------------------------------------------------------------------------
  186.         process_mem_cmd_compare(ppp1,ppp2)
  187. --------------------------------------------------------------------------*/
  188. process_mem_cmd_compare (ppp1, ppp2)
  189.      register process_memory *ppp1;
  190.      register process_memory *ppp2;
  191. {
  192.   int             i, j;
  193.  
  194.  
  195.   if (current_server -> ps_mem_sort_order == 1)
  196.     return (strcmp (ppp2 -> u_psargs, ppp1 -> u_psargs));
  197.   else
  198.     return (strcmp (ppp1 -> u_psargs, ppp2 -> u_psargs));
  199.  
  200. }                /* end of process_mem_cmd_compare */
  201.  
  202. /*+-------------------------------------------------------------------------
  203.         process_mem_none_compare(ppp1,ppp2)
  204. --------------------------------------------------------------------------*/
  205. process_mem_none_compare (ppp1, ppp2)
  206.      register process_memory *ppp1;
  207.      register process_memory *ppp2;
  208. {
  209.  
  210.   if (current_server -> ps_mem_sort_order == 1)
  211.     return (ppp2 -> none - ppp1 -> none);
  212.   else
  213.     return (ppp1 -> none - ppp2 -> none);
  214.  
  215. }                /* end of process_mem_none_compare */
  216.  
  217. /*+-------------------------------------------------------------------------
  218.         process_mem_swap_compare(ppp1,ppp2)
  219. --------------------------------------------------------------------------*/
  220. process_mem_swap_compare (ppp1, ppp2)
  221.      register process_memory *ppp1;
  222.      register process_memory *ppp2;
  223. {
  224.  
  225.   if (current_server -> ps_mem_sort_order == 1)
  226.     return (ppp2 -> swap - ppp1 -> swap);
  227.   else
  228.     return (ppp1 -> swap - ppp2 -> swap);
  229.  
  230. }                /* end of process_mem_swap_compare */
  231.  
  232.  
  233. /*+-------------------------------------------------------------------------
  234.         process_mem_file_compare(ppp1,ppp2)
  235. --------------------------------------------------------------------------*/
  236. process_mem_file_compare (ppp1, ppp2)
  237.      register process_memory *ppp1;
  238.      register process_memory *ppp2;
  239. {
  240.  
  241.   if (current_server -> ps_mem_sort_order  == 1)
  242.     return (ppp2 -> file - ppp1 -> file);
  243.   else
  244.     return (ppp1 -> file - ppp2 -> file);
  245.  
  246. }                /* end of process_mem_file_compare */
  247.  
  248. /*+-------------------------------------------------------------------------
  249.         process_mem_lstfile_compare(ppp1,ppp2)
  250. --------------------------------------------------------------------------*/
  251. process_mem_lstfile_compare (ppp1, ppp2)
  252.      register process_memory *ppp1;
  253.      register process_memory *ppp2;
  254. {
  255.  
  256.   if (current_server -> ps_mem_sort_order == 1)
  257.     return (ppp2 -> lstfile - ppp1 -> lstfile);
  258.   else
  259.     return (ppp1 -> lstfile - ppp2 -> lstfile);
  260.  
  261. }                /* end of process_mem_lstfile_compare */
  262.  
  263. /*+-------------------------------------------------------------------------
  264.         process_mem_zero_compare(ppp1,ppp2)
  265. --------------------------------------------------------------------------*/
  266. process_mem_zero_compare (ppp1, ppp2)
  267.      register process_memory *ppp1;
  268.      register process_memory *ppp2;
  269. {
  270.  
  271.   if (current_server -> ps_mem_sort_order == 1)
  272.     return (ppp2 -> zero - ppp1 -> zero);
  273.   else
  274.     return (ppp1 -> zero - ppp2 -> zero);
  275.  
  276. }                /* end of process_mem_zero_compare */
  277.  
  278. /*+-------------------------------------------------------------------------
  279.         process_mem_fill_compare(ppp1,ppp2)
  280. --------------------------------------------------------------------------*/
  281. process_mem_fill_compare (ppp1, ppp2)
  282.      register process_memory *ppp1;
  283.      register process_memory *ppp2;
  284. {
  285.  
  286.   if (current_server -> ps_mem_sort_order == 1)
  287.     return (ppp2 -> fill - ppp1 -> fill);
  288.   else
  289.     return (ppp1 -> fill - ppp2 -> fill);
  290.  
  291. }                /* end of process_mem_fill_compare */
  292.  
  293. #ifdef XSW32v5
  294. #define iomap proc
  295. #endif
  296. /*+-------------------------------------------------------------------------
  297.         process_mem_iomap_compare(ppp1,ppp2)
  298. --------------------------------------------------------------------------*/
  299. process_mem_iomap_compare (ppp1, ppp2)
  300.      register process_memory *ppp1;
  301.      register process_memory *ppp2;
  302. {
  303.  
  304.   if (current_server -> ps_mem_sort_order == 1)
  305.     return (ppp2 -> iomap - ppp1 -> iomap);
  306.   else
  307.     return (ppp1 -> iomap - ppp2 -> iomap);
  308.  
  309. }                /* end of process_mem_iomap_compare */
  310.  
  311. /*+-------------------------------------------------------------------------
  312.         process_mem_window_compare(ppp1,ppp2)
  313. --------------------------------------------------------------------------*/
  314. #ifndef XSW32v5
  315. process_mem_window_compare (ppp1, ppp2)
  316.      register process_memory *ppp1;
  317.      register process_memory *ppp2;
  318. {
  319.   if (current_server -> ps_mem_sort_order == 1)
  320.     return (ppp2 -> window - ppp1 -> window);
  321.   else
  322.     return (ppp1 -> window - ppp2 -> window);
  323. }                /* end of process_mem_window_compare */
  324. #endif
  325.  
  326. /*+-------------------------------------------------------------------------
  327.         process_mem_swap_core_compare(ppp1,ppp2)
  328. --------------------------------------------------------------------------*/
  329. process_mem_swap_core_compare (ppp1, ppp2)
  330.      register process_memory *ppp1;
  331.      register process_memory *ppp2;
  332. {
  333.  
  334.   if (current_server -> ps_mem_sort_order == 1)
  335.     return (ppp2 -> swap_core - ppp1 -> swap_core);
  336.   else
  337.     return (ppp1 -> swap_core - ppp2 -> swap_core);
  338.  
  339. }                /* end of process_mem_swap_core_compare */
  340.  
  341. /*+-------------------------------------------------------------------------
  342.         process_mem_file_core_compare(ppp1,ppp2)
  343. --------------------------------------------------------------------------*/
  344. process_mem_file_core_compare (ppp1, ppp2)
  345.      register process_memory *ppp1;
  346.      register process_memory *ppp2;
  347. {
  348.  
  349.   if (current_server -> ps_mem_sort_order == 1)
  350.     return (ppp2 -> file_core - ppp1 -> file_core);
  351.   else
  352.     return (ppp1 -> file_core - ppp2 -> file_core);
  353.  
  354. }                /* end of process_mem_file_core_compare */
  355.  
  356.  
  357. /*+-------------------------------------------------------------------------
  358.         process_mem_lstfile_core_compare(ppp1,ppp2)
  359. --------------------------------------------------------------------------*/
  360. process_mem_lstfile_core_compare (ppp1, ppp2)
  361.      register process_memory *ppp1;
  362.      register process_memory *ppp2;
  363. {
  364.  
  365.   if (current_server -> ps_mem_sort_order == 1)
  366.     return (ppp2 -> lstfile_core - ppp1 -> lstfile_core);
  367.   else
  368.     return (ppp1 -> lstfile_core - ppp2 -> lstfile_core);
  369.  
  370. }                /* end of process_mem_lstfile_core_compare */
  371.  
  372. /*+-------------------------------------------------------------------------
  373.         process_mem_swap_not_core_compare(ppp1,ppp2)
  374. --------------------------------------------------------------------------*/
  375. process_mem_swap_not_core_compare (ppp1, ppp2)
  376.      register process_memory *ppp1;
  377.      register process_memory *ppp2;
  378. {
  379.  
  380.   if (current_server -> ps_mem_sort_order == 1)
  381.     return ((ppp2 -> swap - ppp2 -> swap_core) -
  382.         (ppp1 -> swap - ppp1 -> swap_core));
  383.   else
  384.     return ((ppp1 -> swap - ppp1 -> swap_core) -
  385.         (ppp2 -> swap - ppp2 -> swap_core));
  386.  
  387. }                /* end of process_mem_swap_not_core_compare */
  388.  
  389.  
  390. /*+-------------------------------------------------------------------------
  391.         process_mem_file_not_core_compare(ppp1,ppp2)
  392. --------------------------------------------------------------------------*/
  393. process_mem_file_not_core_compare (ppp1, ppp2)
  394.      register process_memory *ppp1;
  395.      register process_memory *ppp2;
  396. {
  397.  
  398.   if (current_server -> ps_mem_sort_order == 1)
  399.     return ((ppp2 -> file - ppp2 -> file_core) -
  400.         (ppp1 -> file - ppp1 -> file_core));
  401.   else
  402.     return ((ppp1 -> file - ppp1 -> file_core) -
  403.         (ppp2 -> file - ppp2 -> file_core));
  404.  
  405. }                /* end of process_mem_file_not_core_compare */
  406.  
  407. /*+-------------------------------------------------------------------------
  408.         process_mem_lstfile_not_core_compare(ppp1,ppp2)
  409. --------------------------------------------------------------------------*/
  410. process_mem_lstfile_not_core_compare (ppp1, ppp2)
  411.      register process_memory *ppp1;
  412.      register process_memory *ppp2;
  413. {
  414.  
  415.   if (current_server -> ps_mem_sort_order == 1)
  416.     return ((ppp2 -> lstfile - ppp2 -> lstfile_core) -
  417.         (ppp1 -> lstfile - ppp1 -> lstfile_core));
  418.   else
  419.     return ((ppp1 -> lstfile - ppp1 -> lstfile_core) -
  420.         (ppp2 -> lstfile - ppp2 -> lstfile_core));
  421.  
  422. }                /* end of
  423.  
  424.                  * 
  425.                  * 
  426.                  * process_mem_lstfile_not_core_compare */
  427.  
  428.  
  429. /*+-------------------------------------------------------------------------
  430.         process_mem_core_dbd_compare(ppp1,ppp2)
  431. --------------------------------------------------------------------------*/
  432. process_mem_core_dbd_compare (ppp1, ppp2)
  433.      register process_memory *ppp1;
  434.      register process_memory *ppp2;
  435. {
  436.  
  437.   if (current_server -> ps_mem_sort_order == 1)
  438.     return (
  439.          (ppp2 -> none + ppp2 -> swap_core + ppp2 -> file_core + ppp2 -> lstfile_core) -
  440.          (ppp1 -> none + ppp1 -> swap_core + ppp1 -> file_core + ppp1 -> lstfile_core));
  441.   else
  442.     return (
  443.          (ppp1 -> none + ppp1 -> swap_core + ppp1 -> file_core + ppp1 -> lstfile_core) -
  444.          (ppp2 -> none + ppp2 -> swap_core + ppp2 -> file_core + ppp2 -> lstfile_core));
  445.  
  446. }                /* end of process_mem_lstfile_compare */
  447.  
  448.  
  449.  
  450.  
  451. /*+-------------------------------------------------------------------------
  452.     read_memory_stats(SP)
  453.      struct NetworkXswStruct *SP;
  454. --------------------------------------------------------------------------*/
  455. void
  456. read_memory_stats (SP)
  457.  
  458.      struct NetworkXswStruct *SP;
  459.  
  460. {
  461.  
  462.  
  463.   register int    iproc;
  464.  
  465.   preg_t         *mypregion = NULL;
  466.   preg_t         *start_mypregion = NULL;
  467.  
  468.   process_memory *memory_pointer = NULL;
  469.   struct my_proc_struct *mytproc = NULL;
  470.  
  471.   struct region   myregion;
  472.  
  473.   int             unused = 0;
  474.   int             got_data = 0;
  475.  
  476.   int             virtual_size = 0;
  477.   int             private_mem = 0;
  478.   int             shared_mem = 0;
  479.   int             weighted = 0;
  480.  
  481.   int             i;
  482.   int             j;
  483.   int             num_regions = 0;
  484.   int             temp_data;
  485.  
  486. /*
  487.   fprintf(stdout,"in read_memory_stats\n");
  488. */
  489.  
  490.   if (SP-> heap_memory_pointer != NULL)
  491.     {
  492.  
  493.  
  494.       if (SP-> memory_state != NULL)
  495.     {
  496. /*
  497.       fprintf(stdout,"freeing memory_state\n");
  498. */
  499.       free (SP-> memory_state);
  500.     }
  501.  
  502.       SP -> memory_state = SP -> new_memory_state;
  503.  
  504.  
  505.       SP -> current_mem_procs_bak =
  506.     SP -> current_mem_procs;
  507. /*
  508.       fprintf(stdout,"SP -> current_mem_procs_bak =%d\n",
  509.         SP -> current_mem_procs);
  510. */
  511.  
  512.  
  513.       SP -> num_active_process = 0;
  514.       SP -> current_mem_procs = 0;
  515. /*
  516.   fprintf(stdout,"in read_memory_stats1\n");
  517. */
  518.  
  519.       if (SP -> memory_pointer_bak != NULL)
  520.     {
  521. /*
  522.       fprintf(stdout,"freeing SP -> memory_pointer_bak\n");
  523. */
  524.       free (SP -> memory_pointer_bak);
  525.     }
  526.  
  527.       SP -> memory_pointer_bak = (process_memory_bak *)
  528.     calloc (SP -> current_mem_procs_bak,
  529.         sizeof (process_memory_bak));
  530.  
  531.  
  532. /*
  533.   fprintf(stdout,"in read_memory_stats2\n");
  534. */
  535.  
  536.       if (SP -> memory_pointer_bak == NULL)
  537.     {
  538.       disp_msg (colorDisplayMsg.pixel, "COULD NOT MALLOC for PS_MEM 5");
  539.     }
  540.  
  541. /* should use memcpy for this */
  542.  
  543. /*
  544.   fprintf(stdout,"in read_memory_stats3\n");
  545. */
  546.  
  547.       if ((SP -> memory_pointer_bak != NULL) &&
  548.       (SP -> heap_memory_pointer != NULL))
  549.     for (i = 0; i < SP -> current_mem_procs_bak; i++)
  550.       {
  551.         SP -> memory_pointer_bak[i].p_pid = 
  552.             SP -> heap_memory_pointer[i].p_pid;
  553.         SP -> memory_pointer_bak[i].total_1 = 
  554.             SP -> heap_memory_pointer[i].total;
  555.         SP -> memory_pointer_bak[i].virtual = 
  556.             SP -> heap_memory_pointer[i].virtual;
  557.         SP -> memory_pointer_bak[i].shared = 
  558.             SP -> heap_memory_pointer[i].shared;
  559.         SP -> memory_pointer_bak[i].private = 
  560.             SP -> heap_memory_pointer[i].private;
  561.         SP -> memory_pointer_bak[i].weighted = 
  562.             SP -> heap_memory_pointer[i].weighted;
  563.         SP -> memory_pointer_bak[i].none = 
  564.             SP -> heap_memory_pointer[i].none;
  565.         SP -> memory_pointer_bak[i].swap = 
  566.             SP -> heap_memory_pointer[i].swap;
  567.         SP -> memory_pointer_bak[i].file = 
  568.             SP -> heap_memory_pointer[i].file;
  569.         SP -> memory_pointer_bak[i].lstfile = 
  570.             SP -> heap_memory_pointer[i].lstfile;
  571.         SP -> memory_pointer_bak[i].swap_core = 
  572.             SP -> heap_memory_pointer[i].swap_core;
  573.         SP -> memory_pointer_bak[i].file_core = 
  574.             SP -> heap_memory_pointer[i].file_core;
  575.         SP -> memory_pointer_bak[i].lstfile_core = 
  576.             SP -> heap_memory_pointer[i].lstfile_core;
  577.  
  578.         SP -> memory_pointer_bak[i].zero = 
  579.             SP -> heap_memory_pointer[i].zero;
  580.         SP -> memory_pointer_bak[i].fill = 
  581.             SP -> heap_memory_pointer[i].fill;
  582.         SP -> memory_pointer_bak[i].iomap = 
  583.             SP -> heap_memory_pointer[i].iomap;
  584. #ifndef XSW32v5
  585.         SP -> memory_pointer_bak[i].window = 
  586.             SP -> heap_memory_pointer[i].window;
  587. #endif
  588.  
  589.       }
  590.  
  591.       if (SP -> heap_memory_pointer != NULL)
  592.     free (SP -> heap_memory_pointer);
  593.  
  594.       SP -> got_memory_state = 1;
  595.  
  596.     }
  597.  
  598. /*
  599.  * Ask for memory process data....
  600.  */
  601.  
  602.  
  603.   xsw_write (SP,
  604.          SP -> FileDescriptor,
  605.          send_mem_process_data,
  606.          sizeof (int));
  607.  
  608.   xsw_read (SP,
  609.         SP -> FileDescriptor,
  610.         &SP -> current_mem_procs,
  611.         sizeof (int));
  612.  
  613.   xsw_write (SP,
  614.          SP -> FileDescriptor,
  615.          &got_data,
  616.          sizeof (int));
  617.  
  618.   SP -> heap_memory_pointer = (process_memory *)
  619.  
  620.     calloc (SP -> current_mem_procs,
  621.         sizeof (process_memory));
  622. /*
  623.   fprintf(stdout,"new current_mem_procs = %d\n",
  624.         SP -> current_mem_procs);
  625. */
  626.  
  627.   xsw_read (SP,
  628.         SP -> FileDescriptor,
  629.         SP -> heap_memory_pointer,
  630.         sizeof (process_memory) * SP -> current_mem_procs);
  631.  
  632.  
  633.   SP -> num_active_process = SP -> current_mem_procs;
  634.  
  635.  
  636.   SP -> new_memory_state = (int *) calloc (
  637.                     SP -> current_mem_procs,
  638.                             sizeof (int));
  639.  
  640. }
  641.  
  642.  
  643. /*
  644.  * assign_ps_mem_pixels (SP, i, j)
  645.  *
  646.  * Assign colors for each memory type....
  647.  *
  648.  */
  649.  
  650. struct ps_mem_pixel_struct *
  651. assign_ps_mem_pixels (SP, i, j)
  652.      struct NetworkXswStruct *SP;
  653.      int             i;
  654.      int             j;
  655. {
  656.  
  657.   struct ps_mem_pixel_struct *pixel_list;
  658.  
  659.   pixel_list = (struct ps_mem_pixel_struct *)
  660.     calloc (1, sizeof (struct ps_mem_pixel_struct));
  661.  
  662.   if ( (ushort) (SP -> memory_pointer_bak[j].virtual) <
  663.       (ushort) (SP -> heap_memory_pointer[i].virtual) )
  664.     pixel_list -> virtual_pixel = colorPSmemGrowing.pixel;
  665.   else if ((ushort) (SP -> memory_pointer_bak[j].virtual) >
  666.        (ushort) (SP -> heap_memory_pointer[i].virtual) )
  667.     pixel_list -> virtual_pixel = colorPSmemShrinking.pixel;
  668.   else
  669.     pixel_list -> virtual_pixel = colorPSmem.pixel;
  670.  
  671.   if ((ushort) (SP -> memory_pointer_bak[j].shared) <
  672.       (ushort) (SP -> heap_memory_pointer[i].shared) )
  673.     pixel_list -> shared_pixel = colorPSmemGrowing.pixel;
  674.   else if ((ushort) (SP -> memory_pointer_bak[j].shared) >
  675.        (ushort) (SP -> heap_memory_pointer[i].shared) )
  676.     pixel_list -> shared_pixel = colorPSmemShrinking.pixel;
  677.   else
  678.     pixel_list -> shared_pixel = colorPSmem.pixel;
  679.  
  680.   if ((ushort) (SP -> memory_pointer_bak[j].private) <
  681.       (ushort) (SP -> heap_memory_pointer[i].private) )
  682.     pixel_list -> private_pixel = colorPSmemGrowing.pixel;
  683.   else if ((ushort) (SP -> memory_pointer_bak[j].private) >
  684.        (ushort) (SP -> heap_memory_pointer[i].private) )
  685.     pixel_list -> private_pixel = colorPSmemShrinking.pixel;
  686.   else
  687.     pixel_list -> private_pixel = colorPSmem.pixel;
  688.  
  689.   if ((ushort) (SP -> memory_pointer_bak[j].weighted) <
  690.       (ushort) (SP -> heap_memory_pointer[i].weighted) )
  691.     pixel_list -> weighted_pixel = colorPSmemGrowing.pixel;
  692.   else if ((ushort) (SP -> memory_pointer_bak[j].weighted) >
  693.        (ushort) (SP -> heap_memory_pointer[i].weighted) )
  694.     pixel_list -> weighted_pixel = colorPSmemShrinking.pixel;
  695.   else
  696.     pixel_list -> weighted_pixel = colorPSmem.pixel;
  697.  
  698.  
  699.   if ((ushort) (SP -> memory_pointer_bak[j].total_1) <
  700.       (ushort) (SP -> heap_memory_pointer[i].total) )
  701.     pixel_list -> total_1_pixel = colorPSmemGrowing.pixel;
  702.   else if ((ushort) (SP -> memory_pointer_bak[j].total_1) >
  703.        (ushort) (SP -> heap_memory_pointer[i].total) )
  704.     pixel_list -> total_1_pixel = colorPSmemShrinking.pixel;
  705.   else
  706.     pixel_list -> total_1_pixel = colorPSmem.pixel;
  707.  
  708.  
  709.  
  710.  
  711.  
  712.   if ((ushort) (SP -> memory_pointer_bak[j].none) <
  713.       (ushort) (SP -> heap_memory_pointer[i].none) )
  714.     pixel_list -> none_pixel = colorPSmemGrowing.pixel;
  715.   else if ((ushort) (SP -> memory_pointer_bak[j].none) >
  716.        (ushort) (SP -> heap_memory_pointer[i].none) )
  717.     pixel_list -> none_pixel = colorPSmemShrinking.pixel;
  718.   else
  719.     pixel_list -> none_pixel = colorPSmem.pixel;
  720.  
  721.   if ((ushort) (SP -> memory_pointer_bak[j].swap_core) <
  722.       (ushort) (SP -> heap_memory_pointer[i].swap_core) )
  723.     pixel_list -> swap_core_pixel = colorPSmemGrowing.pixel;
  724.   else if ((ushort) (SP -> memory_pointer_bak[j].swap_core) >
  725.        (ushort) (SP -> heap_memory_pointer[i].swap_core) )
  726.     pixel_list -> swap_core_pixel = colorPSmemShrinking.pixel;
  727.   else
  728.     pixel_list -> swap_core_pixel = colorPSmem.pixel;
  729.  
  730.   if ((ushort) (SP -> memory_pointer_bak[j].file_core) <
  731.       (ushort) (SP -> heap_memory_pointer[i].file_core) )
  732.     pixel_list -> file_core_pixel = colorPSmemGrowing.pixel;
  733.   else if ((ushort) (SP -> memory_pointer_bak[j].file_core) >
  734.        (ushort) (SP -> heap_memory_pointer[i].file_core) )
  735.     pixel_list -> file_core_pixel = colorPSmemShrinking.pixel;
  736.   else
  737.     pixel_list -> file_core_pixel = colorPSmem.pixel;
  738.  
  739.   if ((ushort) (SP -> memory_pointer_bak[j].lstfile_core) <
  740.       (ushort) (SP -> heap_memory_pointer[i].lstfile_core) )
  741.     pixel_list -> lstfile_core_pixel = colorPSmemGrowing.pixel;
  742.   else if ((ushort) (SP -> memory_pointer_bak[j].lstfile_core) >
  743.        (ushort) (SP -> heap_memory_pointer[i].lstfile_core) )
  744.     pixel_list -> lstfile_core_pixel = colorPSmemShrinking.pixel;
  745.   else
  746.     pixel_list -> lstfile_core_pixel = colorPSmem.pixel;
  747.  
  748.   if ((ushort) (
  749.     SP -> memory_pointer_bak[j].none +
  750.     SP -> memory_pointer_bak[j].swap_core +
  751.     SP -> memory_pointer_bak[j].file_core +
  752.     SP -> memory_pointer_bak[j].lstfile_core) <
  753.       (ushort) (
  754.     SP -> heap_memory_pointer[i].none +
  755.     SP -> heap_memory_pointer[i].swap_core +
  756.     SP -> heap_memory_pointer[i].file_core +
  757.     SP -> heap_memory_pointer[i].lstfile_core))
  758.  
  759.     pixel_list -> total_2_pixel = colorPSmemGrowing.pixel;
  760.   else if ((ushort)(
  761.          SP -> memory_pointer_bak[j].none +
  762.          SP -> memory_pointer_bak[j].swap_core +
  763.          SP -> memory_pointer_bak[j].file_core +
  764.          SP -> memory_pointer_bak[j].lstfile_core) >
  765.       (ushort) (
  766.          SP -> heap_memory_pointer[i].none +
  767.          SP -> heap_memory_pointer[i].swap_core +
  768.          SP -> heap_memory_pointer[i].file_core +
  769.          SP -> heap_memory_pointer[i].lstfile_core))
  770.     pixel_list -> total_2_pixel = colorPSmemShrinking.pixel;
  771.   else
  772.     pixel_list -> total_2_pixel = colorPSmem.pixel;
  773.  
  774.  
  775.  
  776.  
  777.   if ((ushort) (SP -> memory_pointer_bak[j].swap) <
  778.       (ushort) (SP -> heap_memory_pointer[i].swap) )
  779.     pixel_list -> swap_pixel = colorPSmemGrowing.pixel;
  780.   else if ((ushort) (SP -> memory_pointer_bak[j].swap) >
  781.        (ushort) (SP -> heap_memory_pointer[i].swap) )
  782.     pixel_list -> swap_pixel = colorPSmemShrinking.pixel;
  783.   else
  784.     pixel_list -> swap_pixel = colorPSmem.pixel;
  785.  
  786.   if ((ushort) (SP -> memory_pointer_bak[j].file) <
  787.       (ushort) (SP -> heap_memory_pointer[i].file) )
  788.     pixel_list -> file_pixel = colorPSmemGrowing.pixel;
  789.   else if ((ushort) (SP -> memory_pointer_bak[j].file) >
  790.        (ushort) (SP -> heap_memory_pointer[i].file) )
  791.     pixel_list -> file_pixel = colorPSmemShrinking.pixel;
  792.   else
  793.     pixel_list -> file_pixel = colorPSmem.pixel;
  794.  
  795.   if ((ushort) (SP -> memory_pointer_bak[j].lstfile) <
  796.       (ushort) (SP -> heap_memory_pointer[i].lstfile) )
  797.     pixel_list -> lstfile_pixel = colorPSmemGrowing.pixel;
  798.   else if ((ushort) (SP -> memory_pointer_bak[j].lstfile) >
  799.        (ushort) (SP -> heap_memory_pointer[i].lstfile) )
  800.     pixel_list -> lstfile_pixel = colorPSmemShrinking.pixel;
  801.   else
  802.     pixel_list -> lstfile_pixel = colorPSmem.pixel;
  803.  
  804.  
  805.   if ((ushort) (SP -> memory_pointer_bak[j].zero) <
  806.       (ushort) (SP -> heap_memory_pointer[i].zero) )
  807.     pixel_list -> zero_pixel = colorPSmemGrowing.pixel;
  808.   else if ((ushort) (SP -> memory_pointer_bak[j].zero) >
  809.        (ushort) (SP -> heap_memory_pointer[i].zero) )
  810.     pixel_list -> zero_pixel = colorPSmemShrinking.pixel;
  811.   else
  812.     pixel_list -> zero_pixel = colorPSmem.pixel;
  813.  
  814.   if ((ushort) (SP -> memory_pointer_bak[j].fill) <
  815.       (ushort) (SP -> heap_memory_pointer[i].fill) )
  816.     pixel_list -> fill_pixel = colorPSmemGrowing.pixel;
  817.   else if ((ushort) (SP -> memory_pointer_bak[j].fill) >
  818.        (ushort) (SP -> heap_memory_pointer[i].fill) )
  819.     pixel_list -> fill_pixel = colorPSmemShrinking.pixel;
  820.   else
  821.     pixel_list -> fill_pixel = colorPSmem.pixel;
  822.  
  823.   if ((ushort) (SP -> memory_pointer_bak[j].iomap) <
  824.       (ushort) (SP -> heap_memory_pointer[i].iomap) )
  825.     pixel_list -> iomap_pixel = colorPSmemGrowing.pixel;
  826.   else if ((ushort) (SP -> memory_pointer_bak[j].iomap) >
  827.        (ushort) (SP -> heap_memory_pointer[i].iomap) )
  828.     pixel_list -> iomap_pixel = colorPSmemShrinking.pixel;
  829.   else
  830.     pixel_list -> iomap_pixel = colorPSmem.pixel;
  831.  
  832. #ifndef XSW32v5
  833.   if ((ushort) (SP -> memory_pointer_bak[j].window) <
  834.       (ushort) (SP -> heap_memory_pointer[i].window) )
  835.     pixel_list -> window_pixel = colorPSmemGrowing.pixel;
  836.   else if ((ushort) (SP -> memory_pointer_bak[j].window) >
  837.        (ushort) (SP -> heap_memory_pointer[i].window) )
  838.     pixel_list -> window_pixel = colorPSmemShrinking.pixel;
  839.   else
  840.     pixel_list -> window_pixel = colorPSmem.pixel;
  841. #endif
  842.  
  843.   if ((ushort) (
  844.     SP -> memory_pointer_bak[j].swap -
  845.     SP -> memory_pointer_bak[j].swap_core) <
  846.       (ushort) (
  847.     SP -> heap_memory_pointer[i].swap -
  848.     SP -> heap_memory_pointer[i].swap_core))
  849.     pixel_list -> swap_only_pixel = colorPSmemGrowing.pixel;
  850.   else if ((ushort)(
  851.          SP -> memory_pointer_bak[j].swap -
  852.          SP -> memory_pointer_bak[j].swap_core) >
  853.        (ushort)(
  854.          SP -> heap_memory_pointer[i].swap -
  855.          SP -> heap_memory_pointer[i].swap_core))
  856.     pixel_list -> swap_only_pixel = colorPSmemShrinking.pixel;
  857.   else
  858.     pixel_list -> swap_only_pixel = colorPSmem.pixel;
  859.  
  860.  
  861.   if ((ushort)(
  862.     SP -> memory_pointer_bak[j].file -
  863.     SP -> memory_pointer_bak[j].file_core) <
  864.       (ushort)(
  865.     SP -> heap_memory_pointer[i].file -
  866.     SP -> heap_memory_pointer[i].file_core))
  867.     pixel_list -> file_only_pixel = colorPSmemGrowing.pixel;
  868.   else if ((ushort)(
  869.          SP -> memory_pointer_bak[j].file -
  870.          SP -> memory_pointer_bak[j].file_core) >
  871.        (ushort)(
  872.          SP -> heap_memory_pointer[i].file -
  873.          SP -> heap_memory_pointer[i].file_core))
  874.     pixel_list -> file_only_pixel = colorPSmemShrinking.pixel;
  875.   else
  876.     pixel_list -> file_only_pixel = colorPSmem.pixel;
  877.  
  878.   if ((ushort)(
  879.     SP -> memory_pointer_bak[j].lstfile -
  880.     SP -> memory_pointer_bak[j].lstfile_core) <
  881.       (ushort)(
  882.     SP -> heap_memory_pointer[i].lstfile -
  883.     SP -> heap_memory_pointer[i].lstfile_core))
  884.     pixel_list -> lstfile_only_pixel = colorPSmemGrowing.pixel;
  885.   else if ((ushort)(
  886.          SP -> memory_pointer_bak[j].lstfile -
  887.          SP -> memory_pointer_bak[j].lstfile_core) >
  888.        (ushort)(
  889.          SP -> heap_memory_pointer[i].lstfile -
  890.          SP -> heap_memory_pointer[i].lstfile_core))
  891.     pixel_list -> lstfile_only_pixel = colorPSmemShrinking.pixel;
  892.   else
  893.     pixel_list -> lstfile_only_pixel = colorPSmem.pixel;
  894.  
  895.   return (pixel_list);
  896.  
  897.  
  898. }
  899.  
  900. struct ps_mem_pixel_struct *
  901. determine_ps_mem_pixel (SP, i)
  902.      struct NetworkXswStruct *SP;
  903.      int             i;
  904. {
  905.   int             j = 0;
  906.   int             found_pid = 0;
  907.   struct ps_mem_pixel_struct *pixel_list;
  908.  
  909.  
  910.   if (SP -> memory_pointer_bak != NULL)
  911.     {
  912.  
  913.       if ((i < SP -> current_mem_procs_bak) &&
  914.       (SP -> memory_pointer_bak[i].p_pid == SP -> heap_memory_pointer[i].p_pid))
  915.     {
  916.       j = i;
  917.       found_pid = 1;
  918.  
  919.       pixel_list = assign_ps_mem_pixels (SP, i, i);
  920.  
  921.     }
  922.       else
  923.     for (j = 0; j < SP -> current_mem_procs_bak; j++)
  924.       {
  925.         if (SP -> memory_pointer_bak[j].p_pid ==
  926.         SP -> heap_memory_pointer[i].p_pid)
  927.           {
  928.         found_pid = 1;
  929.  
  930.         pixel_list = assign_ps_mem_pixels (SP, i, j);
  931.  
  932.         break;
  933.  
  934.           }
  935.       }
  936.  
  937.       if (found_pid == 0)
  938.     {
  939.  
  940.       pixel_list = (struct ps_mem_pixel_struct *)
  941.         calloc (1, sizeof (struct ps_mem_pixel_struct));
  942.       pixel_list -> virtual_pixel = colorPSmemNew.pixel;
  943.       pixel_list -> shared_pixel = colorPSmemNew.pixel;
  944.       pixel_list -> private_pixel = colorPSmemNew.pixel;
  945.       pixel_list -> weighted_pixel = colorPSmemNew.pixel;
  946.       pixel_list -> total_1_pixel = colorPSmemNew.pixel;
  947.  
  948.       pixel_list -> none_pixel = colorPSmemNew.pixel;
  949.       pixel_list -> swap_core_pixel = colorPSmemNew.pixel;
  950.       pixel_list -> file_core_pixel = colorPSmemNew.pixel;
  951.       pixel_list -> lstfile_core_pixel = colorPSmemNew.pixel;
  952.       pixel_list -> total_2_pixel = colorPSmemNew.pixel;
  953.  
  954.       pixel_list -> swap_pixel = colorPSmemNew.pixel;
  955.       pixel_list -> file_pixel = colorPSmemNew.pixel;
  956.       pixel_list -> lstfile_pixel = colorPSmemNew.pixel;
  957.       pixel_list -> zero_pixel = colorPSmemNew.pixel;
  958.       pixel_list -> fill_pixel = colorPSmemNew.pixel;
  959.       pixel_list -> iomap_pixel = colorPSmemNew.pixel;
  960.       pixel_list -> window_pixel = colorPSmemNew.pixel;
  961.  
  962.       pixel_list -> swap_only_pixel = colorPSmemNew.pixel;
  963.       pixel_list -> file_only_pixel = colorPSmemNew.pixel;
  964.       pixel_list -> lstfile_only_pixel = colorPSmemNew.pixel;
  965.     }
  966.     }
  967.  
  968.   return (pixel_list);
  969. }
  970.  
  971. /*+-------------------------------------------------------------------------
  972.         update_ps_mem( SP )
  973. --------------------------------------------------------------------------*/
  974. void
  975. update_ps_mem (SP)
  976.      struct NetworkXswStruct *SP;
  977. {
  978.   Window          window = SP -> SEPERATE_WINDOWS_LIST[BUTTON_ps_mem].window;
  979.   Display        *display = SP -> SEPERATE_WINDOWS_LIST[BUTTON_ps_mem].display;
  980.   GC              gc = SP -> SEPERATE_WINDOWS_LIST[BUTTON_ps_mem].gc;
  981.   XWindowAttributes DrawAreaXYWH = SP -> SEPERATE_WINDOWS_LIST[BUTTON_ps_mem].DrawAreaXYWH;
  982.   Pixmap          pixmap = SP -> SEPERATE_WINDOWS_LIST[BUTTON_ps_mem].pixmap;
  983.  
  984.   char            s256[256];
  985.  
  986.   unsigned long   pixel;
  987.   struct ps_mem_pixel_struct *pixel_list = NULL;
  988.  
  989.  
  990.   int             found_pid = 0;
  991.   int             mem_state = 0;
  992.   int             j = 0;
  993.   int             x = 0;
  994.   int             y = 0;
  995.   int             i = 0;
  996.   int             k = 0;
  997.   int             fheight = FHEIGHT;
  998.   int             x1 = 0;
  999.   int             x2 = 0;
  1000.   int             drawn_number = 0;
  1001.  
  1002.   sort_procs (BUTTON_ps_mem);
  1003.  
  1004.   for (i = 0; i < SP -> num_active_process; i++)
  1005.     {
  1006.  
  1007.       x1 = 0;
  1008.       x2 = 0;
  1009.  
  1010.       pixel = colorPSmem.pixel;
  1011.  
  1012. /*
  1013.  * Lets do a little filtering......
  1014.  */
  1015.  
  1016.       if ((((SP -> ps_mem_screen_mode == 1) ||
  1017.         (SP -> ps_mem_screen_mode == 2)) &&
  1018.        (SP -> heap_memory_pointer[i].total > 0)
  1019.       ) ||
  1020.  
  1021.       (SP -> ps_mem_screen_mode == 4) ||
  1022.  
  1023.       (SP -> ps_mem_screen_mode == 3)
  1024.     )
  1025.  
  1026.     {
  1027.  
  1028.           y = drawn_number * fheight;
  1029.       drawn_number++;
  1030.  
  1031.  
  1032. /*
  1033.  * Clear the enitre line
  1034.  */
  1035.  
  1036.       XSetForeground (display, gc, background);
  1037.       XFillRectangle (display, pixmap, gc, x, y,
  1038.                SP -> SEPERATE_WINDOWS_LIST[BUTTON_ps_mem].draw_width - x,
  1039.               FHEIGHT);
  1040.  
  1041.  
  1042.       switch (SP -> ps_mem_screen_mode)
  1043.         {
  1044.  
  1045.         case 1:
  1046. /*
  1047.  * Display Name & Pid
  1048.  */
  1049.  
  1050.           pixel_list = determine_ps_mem_pixel (SP, i);
  1051.  
  1052.           x1 = sprintf (s256,
  1053.                 "%9s %5d  ",
  1054.                 SP -> heap_memory_pointer[i].name,
  1055.                 SP -> heap_memory_pointer[i].p_pid);
  1056.  
  1057.  
  1058.           k = disp_info_text (window, display, gc, DrawAreaXYWH, x2, y,
  1059.                   pixmap, colorPSmem.pixel, s256);
  1060.  
  1061.           x2 += x1 * FWIDTH;
  1062.  
  1063.  
  1064. /*
  1065.  * Display Virtual
  1066.  */
  1067.  
  1068.           x1 = sprintf (s256, "%6d  ",
  1069.                 SP -> heap_memory_pointer[i].virtual);
  1070.  
  1071.           k = disp_info_text (window, display, gc, DrawAreaXYWH, x2, y,
  1072.                   pixmap, pixel_list -> virtual_pixel, s256);
  1073.  
  1074.           x2 += x1 * FWIDTH;
  1075.  
  1076. /*
  1077.  * Display Shared
  1078.  */
  1079.  
  1080.           x1 = sprintf (s256, "%5d ",
  1081.                 SP -> heap_memory_pointer[i].shared);
  1082.  
  1083.           k = disp_info_text (window, display, gc, DrawAreaXYWH, x2, y,
  1084.                   pixmap, pixel_list -> shared_pixel, s256);
  1085.  
  1086.           x2 += x1 * FWIDTH;
  1087.  
  1088. /*
  1089.  * Display Private
  1090.  */
  1091.  
  1092.           x1 = sprintf (s256, "%5d ",
  1093.                 SP -> heap_memory_pointer[i].private);
  1094.  
  1095.           k = disp_info_text (window, display, gc, DrawAreaXYWH, x2, y,
  1096.                   pixmap, pixel_list -> private_pixel, s256);
  1097.  
  1098.           x2 += x1 * FWIDTH;
  1099.  
  1100. /*
  1101.  * Display Weighted
  1102.  */
  1103.  
  1104.           x1 = sprintf (s256, "%4d  ",
  1105.                 SP -> heap_memory_pointer[i].weighted);
  1106.  
  1107.           k = disp_info_text (window, display, gc, DrawAreaXYWH, x2, y,
  1108.                 pixmap, pixel_list -> weighted_pixel, s256);
  1109.  
  1110.           x2 += x1 * FWIDTH;
  1111.  
  1112. /*
  1113.  * Display Total
  1114.  */
  1115.  
  1116.           x1 = sprintf (s256, "%5d  ",
  1117.                 SP -> heap_memory_pointer[i].total);
  1118.  
  1119.           k = disp_info_text (window, display, gc, DrawAreaXYWH, x2, y,
  1120.                   pixmap, pixel_list -> total_1_pixel, s256);
  1121.  
  1122.           x2 += x1 * FWIDTH;
  1123.  
  1124. /*
  1125.  * Display Command
  1126.  */
  1127.  
  1128.           x1 = sprintf (s256, "%s ",
  1129.                 SP -> heap_memory_pointer[i].u_psargs);
  1130.  
  1131.           k = disp_info_text (window, display, gc, DrawAreaXYWH, x2, y,
  1132.                   pixmap, colorPSmem.pixel, s256);
  1133.  
  1134.           x2 += x1 * FWIDTH;
  1135.  
  1136.  
  1137.           break;
  1138.         case 2:
  1139. /*
  1140.  * Display Name & Pid
  1141.  */
  1142.  
  1143.           pixel_list = determine_ps_mem_pixel (SP, i);
  1144.  
  1145.           x1 = sprintf (s256,
  1146.                 "%9s %5d  ",
  1147.                 SP -> heap_memory_pointer[i].name,
  1148.                 SP -> heap_memory_pointer[i].p_pid);
  1149.  
  1150.  
  1151.           k = disp_info_text (window, display, gc, DrawAreaXYWH, x2, y,
  1152.                   pixmap, colorPSmem.pixel, s256);
  1153.  
  1154.           x2 += x1 * FWIDTH;
  1155.  
  1156.  
  1157. /*
  1158.  * Display Virtual
  1159.  */
  1160.  
  1161.           x1 = sprintf (s256, "%6d  ",
  1162.                 SP -> heap_memory_pointer[i].virtual);
  1163.  
  1164.           k = disp_info_text (window, display, gc, DrawAreaXYWH, x2, y,
  1165.                   pixmap, pixel_list -> virtual_pixel, s256);
  1166.  
  1167.           x2 += x1 * FWIDTH;
  1168.  
  1169.           x1 = sprintf (s256, "%5d ",
  1170.                 SP -> heap_memory_pointer[i].none);
  1171.  
  1172.           k = disp_info_text (window, display, gc, DrawAreaXYWH, x2, y,
  1173.                   pixmap, pixel_list -> none_pixel, s256);
  1174.  
  1175.           x2 += x1 * FWIDTH;
  1176.  
  1177.           x1 = sprintf (s256, "%5d ",
  1178.                 SP -> heap_memory_pointer[i].swap_core);
  1179.  
  1180.           k = disp_info_text (window, display, gc, DrawAreaXYWH, x2, y,
  1181.                    pixmap, pixel_list -> swap_core_pixel, s256);
  1182.  
  1183.           x2 += x1 * FWIDTH;
  1184.  
  1185.           x1 = sprintf (s256, "%5d   ",
  1186.                 SP -> heap_memory_pointer[i].file_core);
  1187.  
  1188.           k = disp_info_text (window, display, gc, DrawAreaXYWH, x2, y,
  1189.                    pixmap, pixel_list -> file_core_pixel, s256);
  1190.  
  1191.           x2 += x1 * FWIDTH;
  1192.  
  1193.           x1 = sprintf (s256, "%5d  ",
  1194.                 SP -> heap_memory_pointer[i].lstfile_core);
  1195.  
  1196.           k = disp_info_text (window, display, gc, DrawAreaXYWH, x2, y,
  1197.                 pixmap, pixel_list -> lstfile_core_pixel, s256);
  1198.  
  1199.           x2 += x1 * FWIDTH;
  1200.  
  1201.           x1 = sprintf (s256, "%5d  ",
  1202.                 SP -> heap_memory_pointer[i].none +
  1203.                 SP -> heap_memory_pointer[i].swap_core +
  1204.                 SP -> heap_memory_pointer[i].file_core +
  1205.                 SP -> heap_memory_pointer[i].lstfile_core);
  1206.  
  1207.           k = disp_info_text (window, display, gc, DrawAreaXYWH, x2, y,
  1208.                   pixmap, pixel_list -> total_2_pixel, s256);
  1209.  
  1210.           x2 += x1 * FWIDTH;
  1211.  
  1212.  
  1213. /*
  1214.  * Display Command
  1215.  */
  1216.  
  1217.           x1 = sprintf (s256, "%s ",
  1218.                 SP -> heap_memory_pointer[i].u_psargs);
  1219.  
  1220.           k = disp_info_text (window, display, gc, DrawAreaXYWH, x2, y,
  1221.                   pixmap, colorPSmem.pixel, s256);
  1222.  
  1223.           x2 += x1 * FWIDTH;
  1224.  
  1225.  
  1226.           break;
  1227.         case 3:
  1228.  
  1229. /*
  1230.  * Display Name & Pid
  1231.  */
  1232.  
  1233.           pixel_list = determine_ps_mem_pixel (SP, i);
  1234.  
  1235.           x1 = sprintf (s256,
  1236.                 "%9s %5d  ",
  1237.                 SP -> heap_memory_pointer[i].name,
  1238.                 SP -> heap_memory_pointer[i].p_pid);
  1239.  
  1240.  
  1241.           k = disp_info_text (window, display, gc, DrawAreaXYWH, x2, y,
  1242.                   pixmap, colorPSmem.pixel, s256);
  1243.  
  1244.           x2 += x1 * FWIDTH;
  1245.  
  1246.  
  1247. /*
  1248.  * Display Virtual
  1249.  */
  1250.  
  1251.           x1 = sprintf (s256, "%6d  ",
  1252.                 SP -> heap_memory_pointer[i].virtual);
  1253.  
  1254.           k = disp_info_text (window, display, gc, DrawAreaXYWH, x2, y,
  1255.                   pixmap, pixel_list -> virtual_pixel, s256);
  1256.  
  1257.           x2 += x1 * FWIDTH;
  1258.  
  1259.  
  1260.           x1 = sprintf (s256, "%5d ",
  1261.                 SP -> heap_memory_pointer[i].none);
  1262.  
  1263.           k = disp_info_text (window, display, gc, DrawAreaXYWH, x2, y,
  1264.                   pixmap, pixel_list -> none_pixel, s256);
  1265.  
  1266.           x2 += x1 * FWIDTH;
  1267.  
  1268.           x1 = sprintf (s256, "%5d ",
  1269.                 SP -> heap_memory_pointer[i].swap);
  1270.  
  1271.           k = disp_info_text (window, display, gc, DrawAreaXYWH, x2, y,
  1272.                   pixmap, pixel_list -> swap_pixel, s256);
  1273.  
  1274.           x2 += x1 * FWIDTH;
  1275.  
  1276.           x1 = sprintf (s256, "%5d   ",
  1277.                 SP -> heap_memory_pointer[i].file);
  1278.  
  1279.           k = disp_info_text (window, display, gc, DrawAreaXYWH, x2, y,
  1280.                   pixmap, pixel_list -> file_pixel, s256);
  1281.  
  1282.           x2 += x1 * FWIDTH;
  1283.  
  1284.           x1 = sprintf (s256, "%5d  ",
  1285.                 SP -> heap_memory_pointer[i].lstfile);
  1286.  
  1287.           k = disp_info_text (window, display, gc, DrawAreaXYWH, x2, y,
  1288.                   pixmap, pixel_list -> lstfile_pixel, s256);
  1289.  
  1290.           x2 += x1 * FWIDTH;
  1291.  
  1292.           x1 = sprintf (s256, "%5d  ",
  1293.                 SP -> heap_memory_pointer[i].zero);
  1294.  
  1295.           k = disp_info_text (window, display, gc, DrawAreaXYWH, x2, y,
  1296.                   pixmap, pixel_list -> zero_pixel, s256);
  1297.  
  1298.           x2 += x1 * FWIDTH;
  1299.  
  1300.           x1 = sprintf (s256, "%5d  ",
  1301.                 SP -> heap_memory_pointer[i].fill);
  1302.  
  1303.           k = disp_info_text (window, display, gc, DrawAreaXYWH, x2, y,
  1304.                   pixmap, pixel_list -> fill_pixel, s256);
  1305.  
  1306.           x2 += x1 * FWIDTH;
  1307.  
  1308.           x1 = sprintf (s256, "%5d  ",
  1309.                 SP -> heap_memory_pointer[i].iomap);
  1310.  
  1311.           k = disp_info_text (window, display, gc, DrawAreaXYWH, x2, y,
  1312.                   pixmap, pixel_list -> iomap_pixel, s256);
  1313.  
  1314.           x2 += x1 * FWIDTH;
  1315. #ifndef XSW32v5
  1316.           x1 = sprintf (s256, "%5d  ",
  1317.                 SP -> heap_memory_pointer[i].window);
  1318.  
  1319.           k = disp_info_text (window, display, gc, DrawAreaXYWH, x2, y,
  1320.                   pixmap, pixel_list -> window_pixel, s256);
  1321.  
  1322.           x2 += x1 * FWIDTH;
  1323. #endif
  1324. /*
  1325.  * Display Command
  1326.  */
  1327.  
  1328.           x1 = sprintf (s256, "%s ",
  1329.                 SP -> heap_memory_pointer[i].u_psargs);
  1330.  
  1331.           k = disp_info_text (window, display, gc, DrawAreaXYWH, x2, y,
  1332.                   pixmap, colorPSmem.pixel, s256);
  1333.  
  1334.           x2 += x1 * FWIDTH;
  1335.  
  1336.  
  1337.  
  1338.           break;
  1339.         case 4:
  1340.  
  1341. /*
  1342.  * Display Name & Pid
  1343.  */
  1344.  
  1345.           pixel_list = determine_ps_mem_pixel (SP, i);
  1346.  
  1347.           x1 = sprintf (s256,
  1348.                 "%9s %5d  ",
  1349.                 SP -> heap_memory_pointer[i].name,
  1350.                 SP -> heap_memory_pointer[i].p_pid);
  1351.  
  1352.  
  1353.           k = disp_info_text (window, display, gc, DrawAreaXYWH, x2, y,
  1354.                   pixmap, colorPSmem.pixel, s256);
  1355.  
  1356.           x2 += x1 * FWIDTH;
  1357.  
  1358.  
  1359. /*
  1360.  * Display Virtual
  1361.  */
  1362.  
  1363.           x1 = sprintf (s256, "%6d  ",
  1364.                 SP -> heap_memory_pointer[i].virtual);
  1365.  
  1366.           k = disp_info_text (window, display, gc, DrawAreaXYWH, x2, y,
  1367.                   pixmap, pixel_list -> virtual_pixel, s256);
  1368.  
  1369.           x2 += x1 * FWIDTH;
  1370.  
  1371.           x1 = sprintf (s256, "%5d ",
  1372.                 SP -> heap_memory_pointer[i].swap -
  1373.                 SP -> heap_memory_pointer[i].swap_core);
  1374.  
  1375.           k = disp_info_text (window, display, gc, DrawAreaXYWH, x2, y,
  1376.                    pixmap, pixel_list -> swap_only_pixel, s256);
  1377.  
  1378.           x2 += x1 * FWIDTH;
  1379.  
  1380.           x1 = sprintf (s256, "%5d    ",
  1381.                 SP -> heap_memory_pointer[i].file -
  1382.                 SP -> heap_memory_pointer[i].file_core);
  1383.  
  1384.           k = disp_info_text (window, display, gc, DrawAreaXYWH, x2, y,
  1385.                    pixmap, pixel_list -> file_only_pixel, s256);
  1386.  
  1387.           x2 += x1 * FWIDTH;
  1388.  
  1389.           x1 = sprintf (s256, "%5d ",
  1390.                 SP -> heap_memory_pointer[i].lstfile -
  1391.                 SP -> heap_memory_pointer[i].lstfile_core);
  1392.  
  1393.           k = disp_info_text (window, display, gc, DrawAreaXYWH, x2, y,
  1394.                 pixmap, pixel_list -> lstfile_only_pixel, s256);
  1395.  
  1396.           x2 += x1 * FWIDTH;
  1397. /*
  1398.  
  1399.           x1 = sprintf (s256, "%5d ",
  1400.                   SP -> heap_memory_pointer[i].zero);
  1401.  
  1402.           k = disp_info_text (window, display, gc, DrawAreaXYWH, x2, y,
  1403.                   pixmap, pixel_list -> zero_pixel, s256);
  1404.  
  1405.           x2 += x1 * FWIDTH;
  1406.  
  1407.           x1 = sprintf (s256, "%5d  ",
  1408.                   SP -> heap_memory_pointer[i].fill);
  1409.  
  1410.           k = disp_info_text (window, display, gc, DrawAreaXYWH, x2, y,
  1411.                   pixmap, pixel_list -> fill_pixel, s256);
  1412.  
  1413.           x2 += x1 * FWIDTH;
  1414.  
  1415.           x1 = sprintf (s256, "%5d   ",
  1416.                   SP -> heap_memory_pointer[i].iomap);
  1417.  
  1418.           k = disp_info_text (window, display, gc, DrawAreaXYWH, x2, y,
  1419.                   pixmap, pixel_list -> iomap_pixel, s256);
  1420.  
  1421.           x2 += x1 * FWIDTH;
  1422.           x1 = sprintf (s256, "%5d ",
  1423.                   SP -> heap_memory_pointer[i].window);
  1424.  
  1425.           k = disp_info_text (window, display, gc, DrawAreaXYWH, x2, y,
  1426.                   pixmap, pixel_list -> window_pixel, s256);
  1427.  
  1428.           x2 += x1 * FWIDTH;
  1429. */
  1430.  
  1431. /*
  1432.  * Display Command
  1433.  */
  1434.  
  1435.           x1 = sprintf (s256, "%s ",
  1436.                 SP -> heap_memory_pointer[i].u_psargs);
  1437.  
  1438.           k = disp_info_text (window, display, gc, DrawAreaXYWH, x2, y,
  1439.                   pixmap, colorPSmem.pixel, s256);
  1440.  
  1441.           x2 += x1 * FWIDTH;
  1442.  
  1443.  
  1444.  
  1445.           break;
  1446.         }
  1447.  
  1448.     }
  1449.     else
  1450.     {
  1451. /*
  1452.       fprintf(stdout,"Not drawing %d\n",i);
  1453.       fprintf(stdout,"ps_mem_screen_mode = %d\n",
  1454.             SP -> ps_mem_screen_mode);
  1455.       fprintf(stdout,"total = %d\n",
  1456.             SP -> heap_memory_pointer[i].total);
  1457. */
  1458.  
  1459.     }
  1460.  
  1461.  
  1462.       if (pixel_list != NULL)
  1463.     {
  1464.       free (pixel_list);
  1465.       pixel_list = NULL;
  1466.     }
  1467.  
  1468.     }
  1469.  
  1470.  
  1471.   XSetForeground (display, gc, background);
  1472.   XFillRectangle (display, pixmap, gc,
  1473.           x, drawn_number * fheight,
  1474.           SP -> SEPERATE_WINDOWS_LIST[BUTTON_ps_mem].draw_width,
  1475.           SP -> SEPERATE_WINDOWS_LIST[BUTTON_ps_mem].draw_height);
  1476.  
  1477.   SP -> ps_mem_button_change = 0;
  1478.  
  1479. }
  1480.  
  1481. /* vi: set tabstop=4 shiftwidth=4: */
  1482. /* end of psmem.c */
  1483.